#include <iostream>

using namespace std;

int main(void)
{
    int A;
    int const B = 10;
    //int const B;  --不初始化，报错
    const int C = 20;
    //const int C; --不初始化，报错
    int * const D = &A;
    //int * const D; --不初始化，报错
    cout << A << endl;
    cout << B << endl;
    
    //验证const修饰指针类型，不需要初始化
    const int * E; //不报错
    E = &A;
    cout << C << endl;

    //引用必须初始化，这个和const修饰无关
    int &F = A;
    //int &F; -- 引用不初始化，报错
    const int &G = B;
    cout << G << endl;
    
    //验证附加在const对象上的修改方式
    int const A_c = 20; //A 是const对象
    //int *B_c = &A_c;  //错误, 因为附加在const对象上的间接修改方式是非cosnt限定的
    //int &C_c = A_c;  //错误, 因为附加在const对象上的间接修改方式是非cosnt限定的
    //int * const D_c = &A_c; //错误, 因为附加在const对象上的间接修改方式是非cosnt限定的
    const int * E_c = &A_c; //正确，附加在const对象上的间接修改方式也必须是const限定的
    const int &F_c = A_c;   //正确，附加在const对象上的间接修改方式是const限定的
    cout << E_c << endl;
    cout << F_c << endl;


    //验证将const限定的间接修改方式附加到非const对象上
    int A_b = 30;
    const int * B_b = &A_b;  //ok
    int &B_c = A_b;   //ok
    cout << B_b << endl;
    cout << B_c << endl;


    //验证const限定的间接方式的传递性
    int a = 20;
    int * b = &a; 
    const int * c = b; //可以, 从非const限定 传递到了 const限定
    //int * d = c;       //不可以，从const限定，传递到了非 const限定
    cout << a << endl;
    cout << b << endl;
    cout << c << endl;
    
    int &h = a;
    const int & i = h; //可以, 非const 限定 到 cosnt限定
    //int & j = i;       //不可以，const限定 到 非const限定
    cout << h << endl;
    cout << i << endl;

    return 0;
}